home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / pickle.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  38KB  |  1,410 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Create portable serialized representations of Python objects.
  5.  
  6. See module cPickle for a (much) faster implementation.
  7. See module copy_reg for a mechanism for registering custom picklers.
  8. See module pickletools source for extensive comments.
  9.  
  10. Classes:
  11.  
  12.     Pickler
  13.     Unpickler
  14.  
  15. Functions:
  16.  
  17.     dump(object, file)
  18.     dumps(object) -> string
  19.     load(file) -> object
  20.     loads(string) -> object
  21.  
  22. Misc variables:
  23.  
  24.     __version__
  25.     format_version
  26.     compatible_formats
  27.  
  28. '''
  29. __version__ = '$Revision: 1.158 $'
  30. from types import *
  31. from copy_reg import dispatch_table
  32. from copy_reg import _extension_registry, _inverted_registry, _extension_cache
  33. import marshal
  34. import sys
  35. import struct
  36. import re
  37. import warnings
  38. __all__ = [
  39.     'PickleError',
  40.     'PicklingError',
  41.     'UnpicklingError',
  42.     'Pickler',
  43.     'Unpickler',
  44.     'dump',
  45.     'dumps',
  46.     'load',
  47.     'loads']
  48. format_version = '2.0'
  49. compatible_formats = [
  50.     '1.0',
  51.     '1.1',
  52.     '1.2',
  53.     '1.3',
  54.     '2.0']
  55. HIGHEST_PROTOCOL = 2
  56. mloads = marshal.loads
  57.  
  58. class PickleError(Exception):
  59.     '''A common base class for the other pickling exceptions.'''
  60.     pass
  61.  
  62.  
  63. class PicklingError(PickleError):
  64.     '''This exception is raised when an unpicklable object is passed to the
  65.     dump() method.
  66.  
  67.     '''
  68.     pass
  69.  
  70.  
  71. class UnpicklingError(PickleError):
  72.     '''This exception is raised when there is a problem unpickling an object,
  73.     such as a security violation.
  74.  
  75.     Note that other exceptions may also be raised during unpickling, including
  76.     (but not necessarily limited to) AttributeError, EOFError, ImportError,
  77.     and IndexError.
  78.  
  79.     '''
  80.     pass
  81.  
  82.  
  83. class _Stop(Exception):
  84.     
  85.     def __init__(self, value):
  86.         self.value = value
  87.  
  88.  
  89.  
  90. try:
  91.     from org.python.core import PyStringMap
  92. except ImportError:
  93.     PyStringMap = None
  94.  
  95.  
  96. try:
  97.     UnicodeType
  98. except NameError:
  99.     UnicodeType = None
  100.  
  101. MARK = '('
  102. STOP = '.'
  103. POP = '0'
  104. POP_MARK = '1'
  105. DUP = '2'
  106. FLOAT = 'F'
  107. INT = 'I'
  108. BININT = 'J'
  109. BININT1 = 'K'
  110. LONG = 'L'
  111. BININT2 = 'M'
  112. NONE = 'N'
  113. PERSID = 'P'
  114. BINPERSID = 'Q'
  115. REDUCE = 'R'
  116. STRING = 'S'
  117. BINSTRING = 'T'
  118. SHORT_BINSTRING = 'U'
  119. UNICODE = 'V'
  120. BINUNICODE = 'X'
  121. APPEND = 'a'
  122. BUILD = 'b'
  123. GLOBAL = 'c'
  124. DICT = 'd'
  125. EMPTY_DICT = '}'
  126. APPENDS = 'e'
  127. GET = 'g'
  128. BINGET = 'h'
  129. INST = 'i'
  130. LONG_BINGET = 'j'
  131. LIST = 'l'
  132. EMPTY_LIST = ']'
  133. OBJ = 'o'
  134. PUT = 'p'
  135. BINPUT = 'q'
  136. LONG_BINPUT = 'r'
  137. SETITEM = 's'
  138. TUPLE = 't'
  139. EMPTY_TUPLE = ')'
  140. SETITEMS = 'u'
  141. BINFLOAT = 'G'
  142. TRUE = 'I01\n'
  143. FALSE = 'I00\n'
  144. PROTO = '\x80'
  145. NEWOBJ = '\x81'
  146. EXT1 = '\x82'
  147. EXT2 = '\x83'
  148. EXT4 = '\x84'
  149. TUPLE1 = '\x85'
  150. TUPLE2 = '\x86'
  151. TUPLE3 = '\x87'
  152. NEWTRUE = '\x88'
  153. NEWFALSE = '\x89'
  154. LONG1 = '\x8a'
  155. LONG4 = '\x8b'
  156. _tuplesize2code = [
  157.     EMPTY_TUPLE,
  158.     TUPLE1,
  159.     TUPLE2,
  160.     TUPLE3]
  161. []([] if re.match('[A-Z][A-Z0-9_]+$', x) else _[1])
  162. del x
  163.  
  164. class Pickler:
  165.     
  166.     def __init__(self, file, protocol = None, bin = None):
  167.         '''This takes a file-like object for writing a pickle data stream.
  168.  
  169.         The optional protocol argument tells the pickler to use the
  170.         given protocol; supported protocols are 0, 1, 2.  The default
  171.         protocol is 0, to be backwards compatible.  (Protocol 0 is the
  172.         only protocol that can be written to a file opened in text
  173.         mode and read back successfully.  When using a protocol higher
  174.         than 0, make sure the file is opened in binary mode, both when
  175.         pickling and unpickling.)
  176.  
  177.         Protocol 1 is more efficient than protocol 0; protocol 2 is
  178.         more efficient than protocol 1.
  179.  
  180.         Specifying a negative protocol version selects the highest
  181.         protocol version supported.  The higher the protocol used, the
  182.         more recent the version of Python needed to read the pickle
  183.         produced.
  184.  
  185.         The file parameter must have a write() method that accepts a single
  186.         string argument.  It can thus be an open file object, a StringIO
  187.         object, or any other custom object that meets this interface.
  188.  
  189.         '''
  190.         if protocol is not None and bin is not None:
  191.             raise ValueError, "can't specify both 'protocol' and 'bin'"
  192.         
  193.         if bin is not None:
  194.             warnings.warn("The 'bin' argument to Pickler() is deprecated", DeprecationWarning)
  195.             protocol = bin
  196.         
  197.         if protocol is None:
  198.             protocol = 0
  199.         
  200.         if protocol < 0:
  201.             protocol = HIGHEST_PROTOCOL
  202.         elif protocol <= protocol:
  203.             pass
  204.         elif not protocol <= HIGHEST_PROTOCOL:
  205.             raise ValueError('pickle protocol must be <= %d' % HIGHEST_PROTOCOL)
  206.         
  207.         self.write = file.write
  208.         self.memo = { }
  209.         self.proto = int(protocol)
  210.         self.bin = protocol >= 1
  211.         self.fast = 0
  212.  
  213.     
  214.     def clear_memo(self):
  215.         '''Clears the pickler\'s "memo".
  216.  
  217.         The memo is the data structure that remembers which objects the
  218.         pickler has already seen, so that shared or recursive objects are
  219.         pickled by reference and not by value.  This method is useful when
  220.         re-using picklers.
  221.  
  222.         '''
  223.         self.memo.clear()
  224.  
  225.     
  226.     def dump(self, obj):
  227.         '''Write a pickled representation of obj to the open file.'''
  228.         if self.proto >= 2:
  229.             self.write(PROTO + chr(self.proto))
  230.         
  231.         self.save(obj)
  232.         self.write(STOP)
  233.  
  234.     
  235.     def memoize(self, obj):
  236.         '''Store an object in the memo.'''
  237.         if self.fast:
  238.             return None
  239.         
  240.         if not id(obj) not in self.memo:
  241.             raise AssertionError
  242.         memo_len = len(self.memo)
  243.         self.write(self.put(memo_len))
  244.         self.memo[id(obj)] = (memo_len, obj)
  245.  
  246.     
  247.     def put(self, i, pack = struct.pack):
  248.         if self.bin:
  249.             if i < 256:
  250.                 return BINPUT + chr(i)
  251.             else:
  252.                 return LONG_BINPUT + pack('<i', i)
  253.         
  254.         return PUT + repr(i) + '\n'
  255.  
  256.     
  257.     def get(self, i, pack = struct.pack):
  258.         if self.bin:
  259.             if i < 256:
  260.                 return BINGET + chr(i)
  261.             else:
  262.                 return LONG_BINGET + pack('<i', i)
  263.         
  264.         return GET + repr(i) + '\n'
  265.  
  266.     
  267.     def save(self, obj):
  268.         pid = self.persistent_id(obj)
  269.         if pid:
  270.             self.save_pers(pid)
  271.             return None
  272.         
  273.         x = self.memo.get(id(obj))
  274.         if x:
  275.             self.write(self.get(x[0]))
  276.             return None
  277.         
  278.         t = type(obj)
  279.         f = self.dispatch.get(t)
  280.         if f:
  281.             f(self, obj)
  282.             return None
  283.         
  284.         
  285.         try:
  286.             issc = issubclass(t, TypeType)
  287.         except TypeError:
  288.             issc = 0
  289.  
  290.         if issc:
  291.             self.save_global(obj)
  292.             return None
  293.         
  294.         reduce = dispatch_table.get(t)
  295.         if reduce:
  296.             rv = reduce(obj)
  297.         else:
  298.             reduce = getattr(obj, '__reduce_ex__', None)
  299.             if reduce:
  300.                 rv = reduce(self.proto)
  301.             else:
  302.                 reduce = getattr(obj, '__reduce__', None)
  303.                 if reduce:
  304.                     rv = reduce()
  305.                 else:
  306.                     raise PicklingError("Can't pickle %r object: %r" % (t.__name__, obj))
  307.         if type(rv) is StringType:
  308.             self.save_global(obj, rv)
  309.             return None
  310.         
  311.         if type(rv) is not TupleType:
  312.             raise PicklingError('%s must return string or tuple' % reduce)
  313.         
  314.         l = len(rv)
  315.         if l <= l:
  316.             pass
  317.         elif not l <= 5:
  318.             raise PicklingError('Tuple returned by %s must have two to five elements' % reduce)
  319.         
  320.         self.save_reduce(obj = obj, *rv)
  321.  
  322.     
  323.     def persistent_id(self, obj):
  324.         pass
  325.  
  326.     
  327.     def save_pers(self, pid):
  328.         if self.bin:
  329.             self.save(pid)
  330.             self.write(BINPERSID)
  331.         else:
  332.             self.write(PERSID + str(pid) + '\n')
  333.  
  334.     
  335.     def save_reduce(self, func, args, state = None, listitems = None, dictitems = None, obj = None):
  336.         if not isinstance(args, TupleType):
  337.             if args is None:
  338.                 warnings.warn('__basicnew__ special case is deprecated', DeprecationWarning)
  339.             else:
  340.                 raise PicklingError('args from reduce() should be a tuple')
  341.         
  342.         if not callable(func):
  343.             raise PicklingError('func from reduce should be callable')
  344.         
  345.         save = self.save
  346.         write = self.write
  347.         if self.proto >= 2 and getattr(func, '__name__', '') == '__newobj__':
  348.             cls = args[0]
  349.             if not hasattr(cls, '__new__'):
  350.                 raise PicklingError('args[0] from __newobj__ args has no __new__')
  351.             
  352.             if obj is not None and cls is not obj.__class__:
  353.                 raise PicklingError('args[0] from __newobj__ args has the wrong class')
  354.             
  355.             args = args[1:]
  356.             save(cls)
  357.             save(args)
  358.             write(NEWOBJ)
  359.         else:
  360.             save(func)
  361.             save(args)
  362.             write(REDUCE)
  363.         if obj is not None:
  364.             self.memoize(obj)
  365.         
  366.         if listitems is not None:
  367.             self._batch_appends(listitems)
  368.         
  369.         if dictitems is not None:
  370.             self._batch_setitems(dictitems)
  371.         
  372.         if state is not None:
  373.             save(state)
  374.             write(BUILD)
  375.         
  376.  
  377.     dispatch = { }
  378.     
  379.     def save_none(self, obj):
  380.         self.write(NONE)
  381.  
  382.     dispatch[NoneType] = save_none
  383.     
  384.     def save_bool(self, obj):
  385.         None(self.write if self.proto >= 2 else FALSE)
  386.  
  387.     dispatch[bool] = save_bool
  388.     
  389.     def save_int(self, obj, pack = struct.pack):
  390.         if self.bin:
  391.             if obj >= 0:
  392.                 if obj <= 255:
  393.                     self.write(BININT1 + chr(obj))
  394.                     return None
  395.                 
  396.                 if obj <= 65535:
  397.                     self.write('%c%c%c' % (BININT2, obj & 255, obj >> 8))
  398.                     return None
  399.                 
  400.             
  401.             high_bits = obj >> 31
  402.             if high_bits == 0 or high_bits == -1:
  403.                 self.write(BININT + pack('<i', obj))
  404.                 return None
  405.             
  406.         
  407.         self.write(INT + repr(obj) + '\n')
  408.  
  409.     dispatch[IntType] = save_int
  410.     
  411.     def save_long(self, obj, pack = struct.pack):
  412.         if self.proto >= 2:
  413.             bytes = encode_long(obj)
  414.             n = len(bytes)
  415.             if n < 256:
  416.                 self.write(LONG1 + chr(n) + bytes)
  417.             else:
  418.                 self.write(LONG4 + pack('<i', n) + bytes)
  419.             return None
  420.         
  421.         self.write(LONG + repr(obj) + '\n')
  422.  
  423.     dispatch[LongType] = save_long
  424.     
  425.     def save_float(self, obj, pack = struct.pack):
  426.         if self.bin:
  427.             self.write(BINFLOAT + pack('>d', obj))
  428.         else:
  429.             self.write(FLOAT + repr(obj) + '\n')
  430.  
  431.     dispatch[FloatType] = save_float
  432.     
  433.     def save_string(self, obj, pack = struct.pack):
  434.         if self.bin:
  435.             n = len(obj)
  436.             if n < 256:
  437.                 self.write(SHORT_BINSTRING + chr(n) + obj)
  438.             else:
  439.                 self.write(BINSTRING + pack('<i', n) + obj)
  440.         else:
  441.             self.write(STRING + repr(obj) + '\n')
  442.         self.memoize(obj)
  443.  
  444.     dispatch[StringType] = save_string
  445.     
  446.     def save_unicode(self, obj, pack = struct.pack):
  447.         if self.bin:
  448.             encoding = obj.encode('utf-8')
  449.             n = len(encoding)
  450.             self.write(BINUNICODE + pack('<i', n) + encoding)
  451.         else:
  452.             obj = obj.replace('\\', '\\u005c')
  453.             obj = obj.replace('\n', '\\u000a')
  454.             self.write(UNICODE + obj.encode('raw-unicode-escape') + '\n')
  455.         self.memoize(obj)
  456.  
  457.     dispatch[UnicodeType] = save_unicode
  458.     if StringType == UnicodeType:
  459.         
  460.         def save_string(self, obj, pack = struct.pack):
  461.             unicode = obj.isunicode()
  462.             if self.bin:
  463.                 if unicode:
  464.                     obj = obj.encode('utf-8')
  465.                 
  466.                 l = len(obj)
  467.                 if l < 256 and not unicode:
  468.                     self.write(SHORT_BINSTRING + chr(l) + obj)
  469.                 else:
  470.                     s = pack('<i', l)
  471.                     if unicode:
  472.                         self.write(BINUNICODE + s + obj)
  473.                     else:
  474.                         self.write(BINSTRING + s + obj)
  475.             elif unicode:
  476.                 obj = obj.replace('\\', '\\u005c')
  477.                 obj = obj.replace('\n', '\\u000a')
  478.                 obj = obj.encode('raw-unicode-escape')
  479.                 self.write(UNICODE + obj + '\n')
  480.             else:
  481.                 self.write(STRING + repr(obj) + '\n')
  482.             self.memoize(obj)
  483.  
  484.         dispatch[StringType] = save_string
  485.     
  486.     
  487.     def save_tuple(self, obj):
  488.         write = self.write
  489.         proto = self.proto
  490.         n = len(obj)
  491.         if n == 0:
  492.             if proto:
  493.                 write(EMPTY_TUPLE)
  494.             else:
  495.                 write(MARK + TUPLE)
  496.             return None
  497.         
  498.         save = self.save
  499.         memo = self.memo
  500.         if n <= 3 and proto >= 2:
  501.             for element in obj:
  502.                 save(element)
  503.             
  504.             if id(obj) in memo:
  505.                 get = self.get(memo[id(obj)][0])
  506.                 write(POP * n + get)
  507.             else:
  508.                 write(_tuplesize2code[n])
  509.                 self.memoize(obj)
  510.             return None
  511.         
  512.         write(MARK)
  513.         for element in obj:
  514.             save(element)
  515.         
  516.         if id(obj) in memo:
  517.             get = self.get(memo[id(obj)][0])
  518.             if proto:
  519.                 write(POP_MARK + get)
  520.             else:
  521.                 write(POP * (n + 1) + get)
  522.             return None
  523.         
  524.         self.write(TUPLE)
  525.         self.memoize(obj)
  526.  
  527.     dispatch[TupleType] = save_tuple
  528.     
  529.     def save_empty_tuple(self, obj):
  530.         self.write(EMPTY_TUPLE)
  531.  
  532.     
  533.     def save_list(self, obj):
  534.         write = self.write
  535.         if self.bin:
  536.             write(EMPTY_LIST)
  537.         else:
  538.             write(MARK + LIST)
  539.         self.memoize(obj)
  540.         self._batch_appends(iter(obj))
  541.  
  542.     dispatch[ListType] = save_list
  543.     _BATCHSIZE = 1000
  544.     
  545.     def _batch_appends(self, items):
  546.         save = self.save
  547.         write = self.write
  548.         if not self.bin:
  549.             for x in items:
  550.                 save(x)
  551.                 write(APPEND)
  552.             
  553.             return None
  554.         
  555.         r = xrange(self._BATCHSIZE)
  556.         while items is not None:
  557.             tmp = []
  558.             for i in r:
  559.                 
  560.                 try:
  561.                     x = items.next()
  562.                     tmp.append(x)
  563.                 continue
  564.                 except StopIteration:
  565.                     items = None
  566.                     break
  567.                     continue
  568.                 
  569.  
  570.             
  571.             n = len(tmp)
  572.             if n > 1:
  573.                 write(MARK)
  574.                 for x in tmp:
  575.                     save(x)
  576.                 
  577.                 write(APPENDS)
  578.                 continue
  579.             None<EXCEPTION MATCH>StopIteration
  580.             if n:
  581.                 save(tmp[0])
  582.                 write(APPEND)
  583.                 continue
  584.  
  585.     
  586.     def save_dict(self, obj):
  587.         write = self.write
  588.         if self.bin:
  589.             write(EMPTY_DICT)
  590.         else:
  591.             write(MARK + DICT)
  592.         self.memoize(obj)
  593.         self._batch_setitems(obj.iteritems())
  594.  
  595.     dispatch[DictionaryType] = save_dict
  596.     if PyStringMap is not None:
  597.         dispatch[PyStringMap] = save_dict
  598.     
  599.     
  600.     def _batch_setitems(self, items):
  601.         save = self.save
  602.         write = self.write
  603.         if not self.bin:
  604.             for k, v in items:
  605.                 save(k)
  606.                 save(v)
  607.                 write(SETITEM)
  608.             
  609.             return None
  610.         
  611.         r = xrange(self._BATCHSIZE)
  612.         while items is not None:
  613.             tmp = []
  614.             for i in r:
  615.                 
  616.                 try:
  617.                     tmp.append(items.next())
  618.                 continue
  619.                 except StopIteration:
  620.                     items = None
  621.                     break
  622.                     continue
  623.                 
  624.  
  625.             
  626.             n = len(tmp)
  627.             if n > 1:
  628.                 write(MARK)
  629.                 for k, v in tmp:
  630.                     save(k)
  631.                     save(v)
  632.                 
  633.                 write(SETITEMS)
  634.                 continue
  635.             None<EXCEPTION MATCH>StopIteration
  636.             if n:
  637.                 (k, v) = tmp[0]
  638.                 save(k)
  639.                 save(v)
  640.                 write(SETITEM)
  641.                 continue
  642.  
  643.     
  644.     def save_inst(self, obj):
  645.         cls = obj.__class__
  646.         memo = self.memo
  647.         write = self.write
  648.         save = self.save
  649.         if hasattr(obj, '__getinitargs__'):
  650.             args = obj.__getinitargs__()
  651.             len(args)
  652.             _keep_alive(args, memo)
  653.         else:
  654.             args = ()
  655.         write(MARK)
  656.         if self.bin:
  657.             save(cls)
  658.             for arg in args:
  659.                 save(arg)
  660.             
  661.             write(OBJ)
  662.         else:
  663.             for arg in args:
  664.                 save(arg)
  665.             
  666.             write(INST + cls.__module__ + '\n' + cls.__name__ + '\n')
  667.         self.memoize(obj)
  668.         
  669.         try:
  670.             getstate = obj.__getstate__
  671.         except AttributeError:
  672.             stuff = obj.__dict__
  673.  
  674.         stuff = getstate()
  675.         _keep_alive(stuff, memo)
  676.         save(stuff)
  677.         write(BUILD)
  678.  
  679.     dispatch[InstanceType] = save_inst
  680.     
  681.     def save_global(self, obj, name = None, pack = struct.pack):
  682.         write = self.write
  683.         memo = self.memo
  684.         if name is None:
  685.             name = obj.__name__
  686.         
  687.         module = getattr(obj, '__module__', None)
  688.         if module is None:
  689.             module = whichmodule(obj, name)
  690.         
  691.         
  692.         try:
  693.             __import__(module)
  694.             mod = sys.modules[module]
  695.             klass = getattr(mod, name)
  696.         except (ImportError, KeyError, AttributeError):
  697.             raise PicklingError("Can't pickle %r: it's not found as %s.%s" % (obj, module, name))
  698.  
  699.         if klass is not obj:
  700.             raise PicklingError("Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name))
  701.         
  702.         if self.proto >= 2:
  703.             code = _extension_registry.get((module, name))
  704.             if code:
  705.                 if not code > 0:
  706.                     raise AssertionError
  707.                 if code <= 255:
  708.                     write(EXT1 + chr(code))
  709.                 elif code <= 65535:
  710.                     write('%c%c%c' % (EXT2, code & 255, code >> 8))
  711.                 else:
  712.                     write(EXT4 + pack('<i', code))
  713.                 return None
  714.             
  715.         
  716.         write(GLOBAL + module + '\n' + name + '\n')
  717.         self.memoize(obj)
  718.  
  719.     dispatch[ClassType] = save_global
  720.     dispatch[FunctionType] = save_global
  721.     dispatch[BuiltinFunctionType] = save_global
  722.     dispatch[TypeType] = save_global
  723.  
  724.  
  725. def _keep_alive(x, memo):
  726.     '''Keeps a reference to the object x in the memo.
  727.  
  728.     Because we remember objects by their id, we have
  729.     to assure that possibly temporary objects are kept
  730.     alive by referencing them.
  731.     We store a reference at the id of the memo, which should
  732.     normally not be used unless someone tries to deepcopy
  733.     the memo itself...
  734.     '''
  735.     
  736.     try:
  737.         memo[id(memo)].append(x)
  738.     except KeyError:
  739.         memo[id(memo)] = [
  740.             x]
  741.  
  742.  
  743. classmap = { }
  744.  
  745. def whichmodule(func, funcname):
  746.     '''Figure out the module in which a function occurs.
  747.  
  748.     Search sys.modules for the module.
  749.     Cache in classmap.
  750.     Return a module name.
  751.     If the function cannot be found, return "__main__".
  752.     '''
  753.     mod = getattr(func, '__module__', None)
  754.     if mod is not None:
  755.         return mod
  756.     
  757.     if func in classmap:
  758.         return classmap[func]
  759.     
  760.     for name, module in sys.modules.items():
  761.         if module is None:
  762.             continue
  763.         
  764.         if name != '__main__' and getattr(module, funcname, None) is func:
  765.             break
  766.             continue
  767.     else:
  768.         name = '__main__'
  769.     classmap[func] = name
  770.     return name
  771.  
  772.  
  773. class Unpickler:
  774.     
  775.     def __init__(self, file):
  776.         '''This takes a file-like object for reading a pickle data stream.
  777.  
  778.         The protocol version of the pickle is detected automatically, so no
  779.         proto argument is needed.
  780.  
  781.         The file-like object must have two methods, a read() method that
  782.         takes an integer argument, and a readline() method that requires no
  783.         arguments.  Both methods should return a string.  Thus file-like
  784.         object can be a file object opened for reading, a StringIO object,
  785.         or any other custom object that meets this interface.
  786.         '''
  787.         self.readline = file.readline
  788.         self.read = file.read
  789.         self.memo = { }
  790.  
  791.     
  792.     def load(self):
  793.         '''Read a pickled object representation from the open file.
  794.  
  795.         Return the reconstituted object hierarchy specified in the file.
  796.         '''
  797.         self.mark = object()
  798.         self.stack = []
  799.         self.append = self.stack.append
  800.         read = self.read
  801.         dispatch = self.dispatch
  802.         
  803.         try:
  804.             while None:
  805.                 key = read(1)
  806.         except _Stop:
  807.             stopinst = None
  808.             return stopinst.value
  809.  
  810.  
  811.     
  812.     def marker(self):
  813.         stack = self.stack
  814.         mark = self.mark
  815.         k = len(stack) - 1
  816.         while stack[k] is not mark:
  817.             k = k - 1
  818.         return k
  819.  
  820.     dispatch = { }
  821.     
  822.     def load_eof(self):
  823.         raise EOFError
  824.  
  825.     dispatch[''] = load_eof
  826.     
  827.     def load_proto(self):
  828.         proto = ord(self.read(1))
  829.         if proto <= proto:
  830.             pass
  831.         elif not proto <= 2:
  832.             raise ValueError, 'unsupported pickle protocol: %d' % proto
  833.         
  834.  
  835.     dispatch[PROTO] = load_proto
  836.     
  837.     def load_persid(self):
  838.         pid = self.readline()[:-1]
  839.         self.append(self.persistent_load(pid))
  840.  
  841.     dispatch[PERSID] = load_persid
  842.     
  843.     def load_binpersid(self):
  844.         pid = self.stack.pop()
  845.         self.append(self.persistent_load(pid))
  846.  
  847.     dispatch[BINPERSID] = load_binpersid
  848.     
  849.     def load_none(self):
  850.         self.append(None)
  851.  
  852.     dispatch[NONE] = load_none
  853.     
  854.     def load_false(self):
  855.         self.append(False)
  856.  
  857.     dispatch[NEWFALSE] = load_false
  858.     
  859.     def load_true(self):
  860.         self.append(True)
  861.  
  862.     dispatch[NEWTRUE] = load_true
  863.     
  864.     def load_int(self):
  865.         data = self.readline()
  866.         if data == FALSE[1:]:
  867.             val = False
  868.         elif data == TRUE[1:]:
  869.             val = True
  870.         else:
  871.             
  872.             try:
  873.                 val = int(data)
  874.             except ValueError:
  875.                 val = long(data)
  876.  
  877.         self.append(val)
  878.  
  879.     dispatch[INT] = load_int
  880.     
  881.     def load_binint(self):
  882.         self.append(mloads('i' + self.read(4)))
  883.  
  884.     dispatch[BININT] = load_binint
  885.     
  886.     def load_binint1(self):
  887.         self.append(ord(self.read(1)))
  888.  
  889.     dispatch[BININT1] = load_binint1
  890.     
  891.     def load_binint2(self):
  892.         self.append(mloads('i' + self.read(2) + '\x00\x00'))
  893.  
  894.     dispatch[BININT2] = load_binint2
  895.     
  896.     def load_long(self):
  897.         self.append(long(self.readline()[:-1], 0))
  898.  
  899.     dispatch[LONG] = load_long
  900.     
  901.     def load_long1(self):
  902.         n = ord(self.read(1))
  903.         bytes = self.read(n)
  904.         self.append(decode_long(bytes))
  905.  
  906.     dispatch[LONG1] = load_long1
  907.     
  908.     def load_long4(self):
  909.         n = mloads('i' + self.read(4))
  910.         bytes = self.read(n)
  911.         self.append(decode_long(bytes))
  912.  
  913.     dispatch[LONG4] = load_long4
  914.     
  915.     def load_float(self):
  916.         self.append(float(self.readline()[:-1]))
  917.  
  918.     dispatch[FLOAT] = load_float
  919.     
  920.     def load_binfloat(self, unpack = struct.unpack):
  921.         self.append(unpack('>d', self.read(8))[0])
  922.  
  923.     dispatch[BINFLOAT] = load_binfloat
  924.     
  925.     def load_string(self):
  926.         rep = self.readline()[:-1]
  927.         for q in '"\'':
  928.             if rep.startswith(q):
  929.                 if not rep.endswith(q):
  930.                     raise ValueError, 'insecure string pickle'
  931.                 
  932.                 rep = rep[len(q):-len(q)]
  933.                 break
  934.                 continue
  935.         else:
  936.             raise ValueError, 'insecure string pickle'
  937.         self.append(rep.decode('string-escape'))
  938.  
  939.     dispatch[STRING] = load_string
  940.     
  941.     def load_binstring(self):
  942.         len = mloads('i' + self.read(4))
  943.         self.append(self.read(len))
  944.  
  945.     dispatch[BINSTRING] = load_binstring
  946.     
  947.     def load_unicode(self):
  948.         self.append(unicode(self.readline()[:-1], 'raw-unicode-escape'))
  949.  
  950.     dispatch[UNICODE] = load_unicode
  951.     
  952.     def load_binunicode(self):
  953.         len = mloads('i' + self.read(4))
  954.         self.append(unicode(self.read(len), 'utf-8'))
  955.  
  956.     dispatch[BINUNICODE] = load_binunicode
  957.     
  958.     def load_short_binstring(self):
  959.         len = ord(self.read(1))
  960.         self.append(self.read(len))
  961.  
  962.     dispatch[SHORT_BINSTRING] = load_short_binstring
  963.     
  964.     def load_tuple(self):
  965.         k = self.marker()
  966.         self.stack[k:] = [
  967.             tuple(self.stack[k + 1:])]
  968.  
  969.     dispatch[TUPLE] = load_tuple
  970.     
  971.     def load_empty_tuple(self):
  972.         self.stack.append(())
  973.  
  974.     dispatch[EMPTY_TUPLE] = load_empty_tuple
  975.     
  976.     def load_tuple1(self):
  977.         self.stack[-1] = (self.stack[-1],)
  978.  
  979.     dispatch[TUPLE1] = load_tuple1
  980.     
  981.     def load_tuple2(self):
  982.         self.stack[-2:] = [
  983.             (self.stack[-2], self.stack[-1])]
  984.  
  985.     dispatch[TUPLE2] = load_tuple2
  986.     
  987.     def load_tuple3(self):
  988.         self.stack[-3:] = [
  989.             (self.stack[-3], self.stack[-2], self.stack[-1])]
  990.  
  991.     dispatch[TUPLE3] = load_tuple3
  992.     
  993.     def load_empty_list(self):
  994.         self.stack.append([])
  995.  
  996.     dispatch[EMPTY_LIST] = load_empty_list
  997.     
  998.     def load_empty_dictionary(self):
  999.         self.stack.append({ })
  1000.  
  1001.     dispatch[EMPTY_DICT] = load_empty_dictionary
  1002.     
  1003.     def load_list(self):
  1004.         k = self.marker()
  1005.         self.stack[k:] = [
  1006.             self.stack[k + 1:]]
  1007.  
  1008.     dispatch[LIST] = load_list
  1009.     
  1010.     def load_dict(self):
  1011.         k = self.marker()
  1012.         d = { }
  1013.         items = self.stack[k + 1:]
  1014.         for i in range(0, len(items), 2):
  1015.             key = items[i]
  1016.             value = items[i + 1]
  1017.             d[key] = value
  1018.         
  1019.         self.stack[k:] = [
  1020.             d]
  1021.  
  1022.     dispatch[DICT] = load_dict
  1023.     
  1024.     def _instantiate(self, klass, k):
  1025.         args = tuple(self.stack[k + 1:])
  1026.         del self.stack[k:]
  1027.         instantiated = 0
  1028.         if not args and type(klass) is ClassType and not hasattr(klass, '__getinitargs__'):
  1029.             
  1030.             try:
  1031.                 value = _EmptyClass()
  1032.                 value.__class__ = klass
  1033.                 instantiated = 1
  1034.             except RuntimeError:
  1035.                 pass
  1036.             except:
  1037.                 None<EXCEPTION MATCH>RuntimeError
  1038.             
  1039.  
  1040.         None<EXCEPTION MATCH>RuntimeError
  1041.         if not instantiated:
  1042.             
  1043.             try:
  1044.                 value = klass(*args)
  1045.             except TypeError:
  1046.                 err = None
  1047.                 raise TypeError, 'in constructor for %s: %s' % (klass.__name__, str(err)), sys.exc_info()[2]
  1048.             except:
  1049.                 None<EXCEPTION MATCH>TypeError
  1050.             
  1051.  
  1052.         None<EXCEPTION MATCH>TypeError
  1053.         self.append(value)
  1054.  
  1055.     
  1056.     def load_inst(self):
  1057.         module = self.readline()[:-1]
  1058.         name = self.readline()[:-1]
  1059.         klass = self.find_class(module, name)
  1060.         self._instantiate(klass, self.marker())
  1061.  
  1062.     dispatch[INST] = load_inst
  1063.     
  1064.     def load_obj(self):
  1065.         k = self.marker()
  1066.         klass = self.stack.pop(k + 1)
  1067.         self._instantiate(klass, k)
  1068.  
  1069.     dispatch[OBJ] = load_obj
  1070.     
  1071.     def load_newobj(self):
  1072.         args = self.stack.pop()
  1073.         cls = self.stack[-1]
  1074.         obj = cls.__new__(cls, *args)
  1075.         self.stack[-1] = obj
  1076.  
  1077.     dispatch[NEWOBJ] = load_newobj
  1078.     
  1079.     def load_global(self):
  1080.         module = self.readline()[:-1]
  1081.         name = self.readline()[:-1]
  1082.         klass = self.find_class(module, name)
  1083.         self.append(klass)
  1084.  
  1085.     dispatch[GLOBAL] = load_global
  1086.     
  1087.     def load_ext1(self):
  1088.         code = ord(self.read(1))
  1089.         self.get_extension(code)
  1090.  
  1091.     dispatch[EXT1] = load_ext1
  1092.     
  1093.     def load_ext2(self):
  1094.         code = mloads('i' + self.read(2) + '\x00\x00')
  1095.         self.get_extension(code)
  1096.  
  1097.     dispatch[EXT2] = load_ext2
  1098.     
  1099.     def load_ext4(self):
  1100.         code = mloads('i' + self.read(4))
  1101.         self.get_extension(code)
  1102.  
  1103.     dispatch[EXT4] = load_ext4
  1104.     
  1105.     def get_extension(self, code):
  1106.         nil = []
  1107.         obj = _extension_cache.get(code, nil)
  1108.         if obj is not nil:
  1109.             self.append(obj)
  1110.             return None
  1111.         
  1112.         key = _inverted_registry.get(code)
  1113.         if not key:
  1114.             raise ValueError('unregistered extension code %d' % code)
  1115.         
  1116.         obj = self.find_class(*key)
  1117.         _extension_cache[code] = obj
  1118.         self.append(obj)
  1119.  
  1120.     
  1121.     def find_class(self, module, name):
  1122.         __import__(module)
  1123.         mod = sys.modules[module]
  1124.         klass = getattr(mod, name)
  1125.         return klass
  1126.  
  1127.     
  1128.     def load_reduce(self):
  1129.         stack = self.stack
  1130.         args = stack.pop()
  1131.         func = stack[-1]
  1132.         if args is None:
  1133.             warnings.warn('__basicnew__ special case is deprecated', DeprecationWarning)
  1134.             value = func.__basicnew__()
  1135.         else:
  1136.             value = func(*args)
  1137.         stack[-1] = value
  1138.  
  1139.     dispatch[REDUCE] = load_reduce
  1140.     
  1141.     def load_pop(self):
  1142.         del self.stack[-1]
  1143.  
  1144.     dispatch[POP] = load_pop
  1145.     
  1146.     def load_pop_mark(self):
  1147.         k = self.marker()
  1148.         del self.stack[k:]
  1149.  
  1150.     dispatch[POP_MARK] = load_pop_mark
  1151.     
  1152.     def load_dup(self):
  1153.         self.append(self.stack[-1])
  1154.  
  1155.     dispatch[DUP] = load_dup
  1156.     
  1157.     def load_get(self):
  1158.         self.append(self.memo[self.readline()[:-1]])
  1159.  
  1160.     dispatch[GET] = load_get
  1161.     
  1162.     def load_binget(self):
  1163.         i = ord(self.read(1))
  1164.         self.append(self.memo[repr(i)])
  1165.  
  1166.     dispatch[BINGET] = load_binget
  1167.     
  1168.     def load_long_binget(self):
  1169.         i = mloads('i' + self.read(4))
  1170.         self.append(self.memo[repr(i)])
  1171.  
  1172.     dispatch[LONG_BINGET] = load_long_binget
  1173.     
  1174.     def load_put(self):
  1175.         self.memo[self.readline()[:-1]] = self.stack[-1]
  1176.  
  1177.     dispatch[PUT] = load_put
  1178.     
  1179.     def load_binput(self):
  1180.         i = ord(self.read(1))
  1181.         self.memo[repr(i)] = self.stack[-1]
  1182.  
  1183.     dispatch[BINPUT] = load_binput
  1184.     
  1185.     def load_long_binput(self):
  1186.         i = mloads('i' + self.read(4))
  1187.         self.memo[repr(i)] = self.stack[-1]
  1188.  
  1189.     dispatch[LONG_BINPUT] = load_long_binput
  1190.     
  1191.     def load_append(self):
  1192.         stack = self.stack
  1193.         value = stack.pop()
  1194.         list = stack[-1]
  1195.         list.append(value)
  1196.  
  1197.     dispatch[APPEND] = load_append
  1198.     
  1199.     def load_appends(self):
  1200.         stack = self.stack
  1201.         mark = self.marker()
  1202.         list = stack[mark - 1]
  1203.         list.extend(stack[mark + 1:])
  1204.         del stack[mark:]
  1205.  
  1206.     dispatch[APPENDS] = load_appends
  1207.     
  1208.     def load_setitem(self):
  1209.         stack = self.stack
  1210.         value = stack.pop()
  1211.         key = stack.pop()
  1212.         dict = stack[-1]
  1213.         dict[key] = value
  1214.  
  1215.     dispatch[SETITEM] = load_setitem
  1216.     
  1217.     def load_setitems(self):
  1218.         stack = self.stack
  1219.         mark = self.marker()
  1220.         dict = stack[mark - 1]
  1221.         for i in range(mark + 1, len(stack), 2):
  1222.             dict[stack[i]] = stack[i + 1]
  1223.         
  1224.         del stack[mark:]
  1225.  
  1226.     dispatch[SETITEMS] = load_setitems
  1227.     
  1228.     def load_build(self):
  1229.         stack = self.stack
  1230.         state = stack.pop()
  1231.         inst = stack[-1]
  1232.         setstate = getattr(inst, '__setstate__', None)
  1233.         if setstate:
  1234.             setstate(state)
  1235.             return None
  1236.         
  1237.         slotstate = None
  1238.         if isinstance(state, tuple) and len(state) == 2:
  1239.             (state, slotstate) = state
  1240.         
  1241.         if state:
  1242.             
  1243.             try:
  1244.                 inst.__dict__.update(state)
  1245.             except RuntimeError:
  1246.                 for k, v in state.items():
  1247.                     setattr(inst, k, v)
  1248.                 
  1249.             
  1250.  
  1251.         None<EXCEPTION MATCH>RuntimeError
  1252.         if slotstate:
  1253.             for k, v in slotstate.items():
  1254.                 setattr(inst, k, v)
  1255.             
  1256.         
  1257.  
  1258.     dispatch[BUILD] = load_build
  1259.     
  1260.     def load_mark(self):
  1261.         self.append(self.mark)
  1262.  
  1263.     dispatch[MARK] = load_mark
  1264.     
  1265.     def load_stop(self):
  1266.         value = self.stack.pop()
  1267.         raise _Stop(value)
  1268.  
  1269.     dispatch[STOP] = load_stop
  1270.  
  1271.  
  1272. class _EmptyClass:
  1273.     pass
  1274.  
  1275. import binascii as _binascii
  1276.  
  1277. def encode_long(x):
  1278.     """Encode a long to a two's complement little-endian binary string.
  1279.     Note that 0L is a special case, returning an empty string, to save a
  1280.     byte in the LONG1 pickling context.
  1281.  
  1282.     >>> encode_long(0L)
  1283.     ''
  1284.     >>> encode_long(255L)
  1285.     '\\xff\\x00'
  1286.     >>> encode_long(32767L)
  1287.     '\\xff\\x7f'
  1288.     >>> encode_long(-256L)
  1289.     '\\x00\\xff'
  1290.     >>> encode_long(-32768L)
  1291.     '\\x00\\x80'
  1292.     >>> encode_long(-128L)
  1293.     '\\x80'
  1294.     >>> encode_long(127L)
  1295.     '\\x7f'
  1296.     >>>
  1297.     """
  1298.     if x == 0:
  1299.         return ''
  1300.     
  1301.     if x > 0:
  1302.         ashex = hex(x)
  1303.         if not ashex.startswith('0x'):
  1304.             raise AssertionError
  1305.         njunkchars = 2 + ashex.endswith('L')
  1306.         nibbles = len(ashex) - njunkchars
  1307.         if nibbles & 1:
  1308.             ashex = '0x0' + ashex[2:]
  1309.         elif int(ashex[2], 16) >= 8:
  1310.             ashex = '0x00' + ashex[2:]
  1311.         
  1312.     else:
  1313.         ashex = hex(-x)
  1314.         if not ashex.startswith('0x'):
  1315.             raise AssertionError
  1316.         njunkchars = 2 + ashex.endswith('L')
  1317.         nibbles = len(ashex) - njunkchars
  1318.         if nibbles & 1:
  1319.             nibbles += 1
  1320.         
  1321.         nbits = nibbles * 4
  1322.         x += 0x1L << nbits
  1323.         if not x > 0:
  1324.             raise AssertionError
  1325.         ashex = hex(x)
  1326.         njunkchars = 2 + ashex.endswith('L')
  1327.         newnibbles = len(ashex) - njunkchars
  1328.         if newnibbles < nibbles:
  1329.             ashex = '0x' + '0' * (nibbles - newnibbles) + ashex[2:]
  1330.         
  1331.         if int(ashex[2], 16) < 8:
  1332.             ashex = '0xff' + ashex[2:]
  1333.         
  1334.     if ashex.endswith('L'):
  1335.         ashex = ashex[2:-1]
  1336.     else:
  1337.         ashex = ashex[2:]
  1338.     if not len(ashex) & 1 == 0:
  1339.         raise AssertionError, (x, ashex)
  1340.     binary = _binascii.unhexlify(ashex)
  1341.     return binary[::-1]
  1342.  
  1343.  
  1344. def decode_long(data):
  1345.     '''Decode a long from a two\'s complement little-endian binary string.
  1346.  
  1347.     >>> decode_long(\'\')
  1348.     0L
  1349.     >>> decode_long("\\xff\\x00")
  1350.     255L
  1351.     >>> decode_long("\\xff\\x7f")
  1352.     32767L
  1353.     >>> decode_long("\\x00\\xff")
  1354.     -256L
  1355.     >>> decode_long("\\x00\\x80")
  1356.     -32768L
  1357.     >>> decode_long("\\x80")
  1358.     -128L
  1359.     >>> decode_long("\\x7f")
  1360.     127L
  1361.     '''
  1362.     nbytes = len(data)
  1363.     if nbytes == 0:
  1364.         return 0x0L
  1365.     
  1366.     ashex = _binascii.hexlify(data[::-1])
  1367.     n = long(ashex, 16)
  1368.     if data[-1] >= '\x80':
  1369.         n -= 0x1L << nbytes * 8
  1370.     
  1371.     return n
  1372.  
  1373.  
  1374. try:
  1375.     from cStringIO import StringIO
  1376. except ImportError:
  1377.     __all__.extend
  1378.     __all__.extend
  1379.     from StringIO import StringIO
  1380. except:
  1381.     __all__.extend
  1382.  
  1383.  
  1384. def dump(obj, file, protocol = None, bin = None):
  1385.     Pickler(file, protocol, bin).dump(obj)
  1386.  
  1387.  
  1388. def dumps(obj, protocol = None, bin = None):
  1389.     file = StringIO()
  1390.     Pickler(file, protocol, bin).dump(obj)
  1391.     return file.getvalue()
  1392.  
  1393.  
  1394. def load(file):
  1395.     return Unpickler(file).load()
  1396.  
  1397.  
  1398. def loads(str):
  1399.     file = StringIO(str)
  1400.     return Unpickler(file).load()
  1401.  
  1402.  
  1403. def _test():
  1404.     import doctest as doctest
  1405.     return doctest.testmod()
  1406.  
  1407. if __name__ == '__main__':
  1408.     _test()
  1409.  
  1410.